package org.simplespringframework.util;

import lombok.extern.slf4j.Slf4j;

import java.io.File;
import java.io.FileFilter;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;

/**
 * @BelongsProject: simpleframework
 * @BelongsPackage: org.simplespringframework.util
 * @Author: xshang
 * @CreateTime: 2023-06-24  21:44
 * @Description: 
 * @Version: 1.0
 */
@Slf4j
public class ClassUtil {

    public static final String FILE_PROTOCOL = "file";

    /**
     * 返回一个包路径下的所有类的集合
     * @param packageName packageName
     * @return Set<Class<?>>
     */
    public static Set<Class<?>> extractPackageClass(String packageName) {
        // 1 获取类加载器
        ClassLoader classLoad = getClassLoad();
        // 2 通过类加载器获取到加载的资源
        URL url = classLoad.getResource(packageName.replace(".", "/"));
        if (url == null) {
            log.warn("unable to retrieve anything from package: " + packageName);
            return null;
        }
        // 3 依据不同的资源类型，采用不同的方式获取资源的集合
        Set<Class<?>> classSet = null;
        // 过滤去文件类型的资源 equalsIgnoreCase()忽略大小写对比
        if (url.getProtocol().equalsIgnoreCase(FILE_PROTOCOL)) {
            // 如果协议是file 也就是 是文件
            classSet = new HashSet<>();
            // 包的实际路径
            File packageDirectory = new File(url.getPath());
            // 提取包下所有的class文件
            extractClassFile(classSet,packageDirectory,packageName);

        }
        return classSet;
    }

    /**
     * 提取包下所有的class文件
     * @param classSet classSet
     * @param fileSouse fileSouse
     * @param packageName packageName
     */
    private static void extractClassFile(Set<Class<?>> classSet, File fileSouse, String packageName) {
        // 如果fileSouse 是文件 就终止
        if (!fileSouse.isDirectory()) {
            return;
        }
        // 如果是一个文件夹,就调用listFiles方法获取文件夹下的文件或文件夹
        File[] files = fileSouse.listFiles(new FileFilter() {
            @Override
            public boolean accept(File file) {
                if (file.isDirectory()) {
                    // 是文件夹 收集 返回true
                    return true;
                } else {
                    // 是文件  获取文件的绝对值路径
                    String absoluteFilePath = file.getAbsolutePath();
                    // 判断该文件是否是.class结尾
                    if (absoluteFilePath.endsWith(".class")) {
                        // 是.class结尾的文件  直接加载进 classSet
                        addToClass(absoluteFilePath);
                    }
                }
                // 非目录非class直接过滤掉
                return false;
            }

            /**
             * 根据class文件的绝对值路径，获取并生成class对象，并放入classSet中
             * @param absoluteFilePath 文件的绝对路径
             */
            private void addToClass(String absoluteFilePath) {
                // 1. 从class文件的绝对值路径里提取出包含了package的类名
                //  project\simpleframework\target\classes\com\xshang\entity\dto\MainPageInfoDTO.class
                // 需要替换为com.xshang.entity.dto.MainPageInfoDTO
                // 斜杠替换为 .
                //absoluteFilePath = absoluteFilePath.substring(2);
                // File.separator 获取当前系统下的 路径 斜杠类型
                absoluteFilePath = absoluteFilePath.replace(File.separator, ".");
                String className = absoluteFilePath.substring(absoluteFilePath.indexOf(packageName));
                className = className.substring(0, className.lastIndexOf("."));
                // 2. 通过反射机制获取对应class对象并加入到classSet里
                Class<?> targetClass = loadClass(className);
                classSet.add(targetClass);
            }

        });
        if (files != null) {
            // 递归调用
            for (File file : files) {
                extractClassFile(classSet, file, packageName);
            }
        }
    }


    /**
     * 实例化class
     * @param clazz Class
     * @param accessible 是否支持创建出私有的class对象实例
     * @return 类的实例化
     * @param <T> class的类型
     */
    public static <T> T newInstance(Class<?> clazz,boolean accessible) {
        try {
            Constructor<?> constructor = clazz.getDeclaredConstructor();
            constructor.setAccessible(accessible);
            return (T)constructor.newInstance();
        } catch (Exception e) {
            log.warn("newInstance error -" + e);
            throw new RuntimeException(e);
        }
    }


    /**
     * 获取class对象
     * @param className class全名 = package + 类名
     * @return Class
     */
    public static Class<?> loadClass(String className) {
        try {
            return Class.forName(className);
        } catch (ClassNotFoundException e) {
            log.error("load class error",e);
            throw new RuntimeException(e);
        }
    }

    /**
     * 获取classLoad
     * @return ClassLoader
     */
    public static ClassLoader getClassLoad() {
        return Thread.currentThread().getContextClassLoader();
    }


    /**
     * 设置类的属性值
     * @param field 成员变量
     * @param target 类实例
     * @param value 成员变量的值
     * @param accessible 是否允许设置私有属性
     */
    public static void setField(Field field, Object target, Object value, boolean accessible) {
        field.setAccessible(accessible);
        try {
            field.set(target,value);
        } catch (IllegalAccessException e) {
            log.warn("setField error:" , e);
            throw new RuntimeException(e);
        }
    }


    public static void main(String[] args) {
        System.out.println(File.separator);
        //extractPackageClass("com.xshang.entity");
    }

}
